
/**
 * 
 * 计算三叉搜索树的高度
 * 
 * 题目描述

定义构造三叉搜索树规则如下：

每个节点都存有一个数，当插入一个新的数时，从根节点向下寻找，直到找到一个合适的空节点插入。查找的规则是：

如果数小于节点的数减去500，则将数插入节点的左子树
如果数大于节点的数加上500，则将数插入节点的右子树
否则，将数插入节点的中子树
给你一系列数，请按以上规则，按顺序将数插入树中，构建出一棵三叉搜索树，最后输出树的高度。

输入描述
第一行为一个数 N，表示有 N 个数，1 ≤ N ≤ 10000

第二行为 N 个空格分隔的整数，每个数的范围为[1,10000]

输出描述
输出树的高度（根节点的高度为1）

用例
输入	5
5000 2000 5000 8000 1800
输出	3
说明	
最终构造出的树如下，高度为3：

输入	3
5000 4000 3000
输出	3
说明	
最终构造出的树如下，高度为3：

输入	9
5000 2000 5000 8000 1800 7500 4500 1400 8100
输出	4
说明	
最终构造出的树如下，高度为4：
 * 
 */

import java.util.Scanner;

import javax.swing.tree.TreeNode;

/**
  * 
  本题应该只是需要模拟出三叉树结构，以及根据指定的逻辑进行插入新节点。

  三叉树插入新节点node逻辑：

如果三叉树为空，则三叉树根节点root = 新节点node
如果三叉树不为空，则从三叉树根节点作为比较节点cur开始比较：
如果 node.val < cur.val - 500，则node应该插入到cur节点的左子树中，
若 cur 节点不存在左子树，那么 node 就作为 cur 节点的左子树根节点，且node.height = cur.height + 1
若 cur 节点存在左子树，那么 cur = cur.left，继续和 node 比较
如果 node.val > cur.val + 500，则node应该插入到cur节点的右子树中，
若 cur 节点不存在右子树，那么 node 就作为 cur 节点的右子树根节点，且node.height = cur.height + 1
若 cur 节点存在右子树，那么 cur = cur.right，继续和 node 比较
其他情况，则 node 应该插入到 cur 节点的中子树中，
若 cur 节点不存在中子树，那么 node 就作为 cur 节点的中子树根节点，且且node.height = cur.height + 1
若 cur 节点存在中子树，那么 cur = cur.mid，继续和 node 比较
在上面比较过程，始终保留最大的node.height作为tree.height。

  */
public class 计算三叉搜索树的高度 {
   
    public static void main(String[] args) {
    

        try{

            Scanner scanner = new Scanner(System.in);

            int nodeCount = scanner.nextInt();

            TreeInfo tree = new TreeInfo();

            for(int i=0; i<nodeCount; i++ ){

                int nodeValue = scanner.nextInt();

                tree.addNode(nodeValue);

            }

            System.out.println(tree.treeHeigth);



        }catch(Exception e){
            e.printStackTrace();
        }
    }

    private static class TreeNodeInfo{

        public int value; //节点的值
        public int heigth; //节点的高度
        public TreeNodeInfo leftNode; // 节点的左节点
        public TreeNodeInfo rightNode; // 节点的右节点
        public TreeNodeInfo centerNode; // 节点的中节点

        public TreeNodeInfo(int value){

            this.value = value;
        }
    }

    private static class TreeInfo {
    
        //根节点
        public TreeNodeInfo rootNode;
        public int treeHeigth; //树的高度

        //添加节点
        public void addNode(int value){

            //添加的节点
            TreeNodeInfo newNode = new TreeNodeInfo(value);

            if(this.rootNode == null){

                //添加第一个节点当做根节点
                this.rootNode = newNode;
                rootNode.heigth = 1;
                this.treeHeigth = 1;
            } else{

                // 如果树不是空的，则从根节点开始比较
                TreeNodeInfo curNode = this.rootNode;

                while (true) {
                    
                    // 假设创建的节点node是当前节点cur的子节点，则node节点高度值=cur节点高度值+
                    newNode.heigth = curNode.heigth + 1;
                    //如果创建的node进入新层，则更新树的高度
                    this.treeHeigth = Math.max(newNode.heigth, this.treeHeigth);

                    if (value < curNode.value - 500) {

                        //添加到左节点
                        if(curNode.leftNode == null){
                            curNode.leftNode = newNode;
                            break;
                        } else {

                            //继续循环判断
                            curNode = curNode.leftNode;
                        }

                    } else if(value > curNode.value - 500){
                    

                        //添加到右节点
                        if(curNode.rightNode == null){
                            curNode.rightNode = newNode;
                            break;
                        } else {

                            //继续循环判断
                            curNode = curNode.rightNode;
                        }
                    } else{

                        //添加到中节点
                        if(curNode.centerNode == null){
                            curNode.centerNode = newNode;
                            break;
                        } else {

                            //继续循环判断
                            curNode = curNode.centerNode;
                        }
                    }

                }
            }
        }
        
        
    }
}
